<html>
	<head>
		<meta charset="utf-8"/>
		<title>BWidget</title>
		<link rel="stylesheet" type="text/css" href="../style.css"/>
	</head>
	<body>
		<h1>BFont</h1>
		<p>Inherites from <a href="BObject.html">BObject</a></p>
		<h2>public</h2>
		<table id="public">
			<tr><td align="right"/><td><a href="#BWidget(BWidget*)">BWidget</a>(BWidget* parent = 0);</td></tr>
			<tr><td align="right"/><td><a href="#BWidget(const BString&,BWidget*)">BWidget</a>(const BString& name, BWidget* parent = 0);</td></tr>
			<tr><td align="right"/><td><a href="#~BWidget()">~BWidget</a>();</td></tr>
			<tr><td align="right">bool </td><td><a href="#active()">active</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#show()">show</a>();</td></tr>
			<tr><td align="right">void </td><td><a href="#hide()">hide</a>();</td></tr>
			<tr><td align="right">void </td><td><a href="#popup()">popup</a>();</td></tr>
			<tr><td align="right">void </td><td><a href="#raise()">raise</a>();</td></tr>
			<tr><td align="right">void </td><td><a href="#lower()">lower</a>();</td></tr>
			<tr><td align="right">void </td><td><a href="#fresh()">fresh</a>();</td></tr>
			<tr><td align="right">void </td><td><a href="#adjust()">adjust</a>();</td></tr>
			<tr><td align="right">virtual bool </td><td><a href="#setAble(bool)">setAble</a>(bool able);</td></tr>
			<tr><td align="right">virtual bool </td><td><a href="#setTitle(const BString&)">setTitle</a>(const BString& title);</td></tr>
			<tr><td align="right">const BString& </td><td><a href="#title()">title</a>() const;</td></tr>
			<tr><td align="right">virtual bool </td><td><a href="#setTitleIcon(BIcon*)">setTitleIcon</a>(BIcon* titleIcon);</td></tr>
			<tr><td align="right">const BIcon* </td><td><a href="#titleIcon()">titleIcon</a>() const;</td></tr>
			<tr><td align="right">BIcon* </td><td><a href="#titleIcon()">titleIcon</a>();</td></tr>
			<tr><td align="right">void </td><td><a href="#setTips(const BString&)">setTips</a>(const BString& tips);</td></tr>
			<tr><td align="right">const BString& </td><td><a href="#tips()">tips</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setVisible(bool)">setVisible</a>(bool visible);</td></tr>
			<tr><td align="right">bool </td><td><a href="#visible()">visible</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setModal(bool)">setModal</a>(bool modal);</td></tr>
			<tr><td align="right">bool </td><td><a href="#modal()">modal</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setFloating(bool)">setFloating</a>(bool floating);</td></tr>
			<tr><td align="right">bool </td><td><a href="#floating()">floating</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setDroppable(bool)">setDroppable</a>(bool droppable);</td></tr>
			<tr><td align="right">bool </td><td><a href="#droppable()">droppable</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setFocusable(bool)">setFocusable</a>(bool focusable);</td></tr>
			<tr><td align="right">bool </td><td><a href="#focusable()">focusable</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setFocus(bool)">setFocus</a>(bool focus);</td></tr>
			<tr><td align="right">bool </td><td><a href="#focus()">focus</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#move(const BPoint&)">move</a>(const BPoint& offset);</td></tr>
			<tr><td align="right">void </td><td><a href="#move(int, int)">move</a>(int ox, int oy);</td></tr>
			<tr><td align="right">void </td><td><a href="#setPos(int, int)">setPos</a>(int x, int y);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#setPos(const BPoint&)">setPos</a>(const BPoint& pos);</td></tr>
			<tr><td align="right">const BPoint& </td><td><a href="#pos()">pos</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setSize(int, int)">setSize</a>(int width, int height);</td></tr>
			<tr><td align="right">void </td><td><a href="#setSize(const BSize&)">setSize</a>(const BSize& size);</td></tr>
			<tr><td align="right">const BSize& </td><td><a href="#size()">size</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setWidth(int)">setWidth</a>(int width);</td></tr>
			<tr><td align="right">int </td><td><a href="#width()">width</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setHeight(int)">setHeight</a>(int height);</td></tr>
			<tr><td align="right">int </td><td><a href="#height()">height</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setAbsolutePos(const BPoint&)">setAbsolutePos</a>(const BPoint& pos);</td></tr>
			<tr><td align="right">void </td><td><a href="#setAbsolutePos(int, int)">setAbsolutePos</a>(int absoluteX, int absoluteY);</td></tr>
			<tr><td align="right">BPoint </td><td><a href="#absolutePos()">absolutePos</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setGlobalPos(const BPoint&)">setGlobalPos</a>(const BPoint& globalPos);</td></tr>
			<tr><td align="right">void </td><td><a href="#setGlobalPos(int, int)">setGlobalPos</a>(int globalX, int globalY);</td></tr>
			<tr><td align="right">BPoint </td><td><a href="#globalPos()">globalPos</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setRect(const BRect&)">setRect</a>(const BRect& rect);</td></tr>
			<tr><td align="right">void </td><td><a href="#setRect(int, int, int, int)">setRect</a>(int x, int y, int width, int height);</td></tr>
			<tr><td align="right">BRect </td><td><a href="#rect()">rect</a>() const;</td></tr>
			<tr><td align="right">BRect </td><td><a href="#rect(Part)">rect</a>(Part part) const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setAbsoluteRect(const BRect&)">setAbsoluteRect</a>(const BRect& rect);</td></tr>
			<tr><td align="right">void </td><td><a href="#setAbsoluteRect(int, int, int, int)">setAbsoluteRect</a>(int x, int y, int width, int height);</td></tr>
			<tr><td align="right">BRect </td><td><a href="#absoluteRect()">absoluteRect</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setGlobalRect(const BRect&)">setGlobalRect</a>(const BRect& rect);</td></tr>
			<tr><td align="right">void </td><td><a href="#setGlobalRect(int, int, int, int)">setGlobalRect</a>(int x, int y, int width, int height);</td></tr>
			<tr><td align="right">BRect </td><td><a href="#globalRect()">globalRect</a>() const;</td></tr>
			<tr><td align="right">BPoint </td><td><a href="#mapTo(const BWidget*, const BPoint&)">mapTo</a>(const BWidget* widget, const BPoint& point) const;</td></tr>
			<tr><td align="right">BPoint </td><td><a href="#mapFrom(const BWidget*, const BPoint&)">mapFrom</a>(const BWidget* widget, const BPoint& point) const;</td></tr>
			<tr><td align="right">BRect </td><td><a href="#mapTo(const BWidget*, const BRect&)">mapTo</a>(const BWidget* widget, const BRect& rect) const;</td></tr>
			<tr><td align="right">BRect </td><td><a href="#mapFrom(const BWidget*, const BRect&)">mapFrom</a>(const BWidget* widget, const BRect& rect) const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setMinSize(const BSize&)">setMinSize</a>(const BSize& minSize);</td></tr>
			<tr><td align="right">void </td><td><a href="#setMinSize(int, int)">setMinSize</a>(int minWidth, int minHeight);</td></tr>
			<tr><td align="right">const BSize& </td><td><a href="#minSize()">minSize</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setMaxSize(const BSize&)">setMaxSize</a>(const BSize& maxSize);</td></tr>
			<tr><td align="right">void </td><td><a href="#setMaxSize(int, int)">setMaxSize</a>(int maxWidth, int maxHeight);</td></tr>
			<tr><td align="right">const BSize& </td><td><a href="#maxSize()">maxSize</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setFixedWidth(int)">setFixedWidth</a>(int fixedWidth);</td></tr>
			<tr><td align="right">void </td><td><a href="#setFixedHeight(int)">setFixedHeight</a>(int fixedHeight);</td></tr>
			<tr><td align="right">void </td><td><a href="#setFixedSize(int, int)">setFixedSize</a>(int fixedWidth, int fixedHeight);</td></tr>
			<tr><td align="right">void </td><td><a href="#setFixedSize(const BSize&)">setFixedSize</a>(const BSize& fixedSize);</td></tr>
			<tr><td align="right">const BSize& </td><td><a href="#fixedSize()">fixedSize</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setWidthStretch(float)">setWidthStretch</a>(float widthStretch);</td></tr>
			<tr><td align="right">float </td><td><a href="#widthStretch()">widthStretch</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setHeightStretch(float)">setHeightStretch</a>(float heightStretch);</td></tr>
			<tr><td align="right">float </td><td><a href="#heightStretch()">heightStretch</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setSizeStretch(float, float)">setSizeStretch</a>(float widthStretch, float heightStretch);</td></tr>
			<tr><td align="right">void </td><td><a href="#setSizeStretch(const BSizeStretch&)">setSizeStretch</a>(const BSizeStretch& sizeStretch);</td></tr>
			<tr><td align="right">const BSizeStretch& </td><td><a href="#sizeStretch()">sizeStretch</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setWidthPolicy(Policy)">setWidthPolicy</a>(Policy widthPolicy);</td></tr>
			<tr><td align="right">Policy </td><td><a href="#widthPolicy()">widthPolicy</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setHeightPolicy(Policy)">setHeightPolicy</a>(Policy heightPolicy);</td></tr>
			<tr><td align="right">Policy </td><td><a href="#heightPolicy()">heightPolicy</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setSizePolicy(Policy, Policy)">setSizePolicy</a>(Policy widthPolicy, Policy heightPolicy);</td></tr>
			<tr><td align="right">void </td><td><a href="#setSizePolicy(const BSizePolicy&)">setSizePolicy</a>(const BSizePolicy& sizePolicy);</td></tr>
			<tr><td align="right">const BSizePolicy& </td><td><a href="#sizePolicy()">sizePolicy</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setClientSize(const BSize&)">setClientSize</a>(const BSize& clientSize);</td></tr>
			<tr><td align="right">void </td><td><a href="#setClientSize(int, int)">setClientSize</a>(int clientWidth, int clientHeight);</td></tr>
			<tr><td align="right">const BRect& </td><td><a href="#clientRect()">clientRect</a>() const;</td></tr>
			<tr><td align="right">BSize </td><td><a href="#clientSize()">clientSize</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setBorder(int)">setBorder</a>(int border);</td></tr>
			<tr><td align="right">int </td><td><a href="#border()">border</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setPerchs(const BPerchs&)">setPerchs</a>(const BPerchs& perchs);</td></tr>
			<tr><td align="right">void </td><td><a href="#setPerchs(int, int, int, int)">setPerchs</a>(int left, int top, int right, int bottom);</td></tr>
			<tr><td align="right">const BPerchs& </td><td><a href="#perchs()">perchs</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setPerch(Part, int)">setPerch</a>(Part part, int value);</td></tr>
			<tr><td align="right">int </td><td><a href="#perch(Part)">perch</a>(Part part) const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setMargins(const BMargins&)">setMargins</a>(const BMargins& margins);</td></tr>
			<tr><td align="right">void </td><td><a href="#setMargins(int, int, int, int)">setMargins</a>(int left, int top, int right, int bottom);</td></tr>
			<tr><td align="right">const BMargins& </td><td><a href="#margins()">margins</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setMargin(Part, int)">setMargin</a>(Part part, int value);</td></tr>
			<tr><td align="right">int </td><td><a href="#margin(Part)">margin</a>(Part part) const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setCursor(CursorType)">setCursor</a>(CursorType cursor);</td></tr>
			<tr><td align="right">void </td><td><a href="#setCursor(BCursor*)">setCursor</a>(BCursor* cursor);</td></tr>
			<tr><td align="right">BCursor* </td><td><a href="#cursor()">cursor</a>();</td></tr>
			<tr><td align="right">const BCursor* </td><td><a href="#cursor()">cursor</a>() const;</td></tr>
			<tr><td align="right">const BCursor* </td><td><a href="#realCursor()">realCursor</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setFont(BFont*)">setFont</a>(BFont* font);</td></tr>
			<tr><td align="right">void </td><td><a href="#setFont(const BString&,int)">setFont</a>(const BString& family, int size = 20);</td></tr>
			<tr><td align="right">const BFont* </td><td><a href="#font()">font</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setStyle(BStyle*)">setStyle</a>(BStyle* style);</td></tr>
			<tr><td align="right">BStyle* </td><td><a href="#style()">style</a>() const;</td></tr>
			<tr><td align="right">BStyle* </td><td><a href="#realStyle()">realStyle</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setStyleSheet(const BString&)">setStyleSheet</a>(const BString& styleSheet);</td></tr>
			<tr><td align="right">const BString& </td><td><a href="#styleSheet()">styleSheet</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setLayout(BLayout*,Part)">setLayout</a>(BLayout* layout, Part part = Part_Center);</td></tr>
			<tr><td align="right">BLayout* </td><td><a href="#layout(Part)">layout</a>(Part part = Part_Center);</td></tr>
			<tr><td align="right">const BLayout* </td><td><a href="#layout(Part)">layout</a>(Part part = Part_Center) const;</td></tr>
			<tr><td align="right">bool </td><td><a href="#removeLayout(BLayout*)">removeLayout</a>(BLayout* layout);</td></tr>
			<tr><td align="right">BSize </td><td><a href="#preferSize(const BSize&)">preferSize</a>(const BSize& csize) const;</td></tr>
			<tr><td align="right">virtual BSize </td><td><a href="#sizeHint()">sizeHint</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#hintSize()">hintSize</a>();</td></tr>
			<tr><td align="right">virtual bool </td><td><a href="#catchPoint(const BPoint&)">catchPoint</a>(const BPoint& point) const;</td></tr>
			<tr><td align="right">BWidget* </td><td><a href="#root()">root</a>();</td></tr>
			<tr><td align="right">const BWidget* </td><td><a href="#root()">root</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#setParent(BWidget*)">setParent</a>(BWidget* parent);</td></tr>
			<tr><td align="right">BWidget* </td><td><a href="#parent()">parent</a>();</td></tr>
			<tr><td align="right">const BWidget* </td><td><a href="#parent()">parent</a>() const;</td></tr>
			<tr><td align="right">void </td><td><a href="#addChild(BWidget*)">addChild</a>(BWidget* child);</td></tr>
			<tr><td align="right">void </td><td><a href="#removeChild(BWidget*)">removeChild</a>(BWidget* child);</td></tr>
			<tr><td align="right">void </td><td><a href="#clearChildren()">clearChildren</a>();</td></tr>
			<tr><td align="right">int </td><td><a href="#childCount()">childCount</a>() const;</td></tr>
			<tr><td align="right">BWidget* </td><td><a href="#child(int)">child</a>(int index);</td></tr>
			<tr><td align="right">const BWidget* </td><td><a href="#child(int)">child</a>(int index) const;</td></tr>
			<tr><td align="right">BWidget* </td><td><a href="#child(const BString&)">child</a>(const BString& name);</td></tr>
			<tr><td align="right">const BWidget* </td><td><a href="#child(const BString&)">child</a>(const BString& name) const;</td></tr>
			<tr><td align="right">BWidget* </td><td><a href="#find(const BString&)">find</a>(const BString& name);</td></tr>
			<tr><td align="right">const BWidget* </td><td><a href="#find(const BString&)">find</a>(const BString& name) const;</td></tr>
			<tr><td align="right">bool </td><td><a href="#contains(const BWidget*)">contains</a>(const BWidget* child);</td></tr>
			<tr><td align="right">int </td><td><a href="#index()">index</a>() const;</td></tr>
		</table>
		<h2>protected</h2>
		<table id="protected">
			<tr><td align="right">virtual void </td><td><a href="#event(const BEvent&)">event</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#showEvent(const BEvent&)">showEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#hideEvent(const BEvent&)">hideEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#moveEvent(const BEvent&)">moveEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#resizeEvent(const BEvent&)">resizeEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#updateEvent(const BEvent&)">updateEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#adjustEvent(const BEvent&)">adjustEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#styleEvent(const BEvent&)">styleEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#freshEvent(const BEvent&)">freshEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#paintEvent(const BEvent&)">paintEvent</a>(const BEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#activeEvent(const BActiveEvent&)">activeEvent</a>(const BActiveEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#focusEvent(const BFocusEvent&)">focusEvent</a>(const BFocusEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#keyDownEvent(const BKeyEvent&)">keyDownEvent</a>(const BKeyEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#keyUpEvent(const BKeyEvent&)">keyUpEvent</a>(const BKeyEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#charEvent(const BCharEvent&)">charEvent</a>(const BCharEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#mouseEnterEvent(const BMouseEvent&)">mouseEnterEvent</a>(const BMouseEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#mouseLeaveEvent(const BMouseEvent&)">mouseLeaveEvent</a>(const BMouseEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#mousePressEvent(const BMouseEvent&)">mousePressEvent</a>(const BMouseEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#mouseReleaseEvent(const BMouseEvent&)">mouseReleaseEvent</a>(const BMouseEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#mouseMoveEvent(const BMouseEvent&)">mouseMoveEvent</a>(const BMouseEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#mouseWheelEvent(const BMouseEvent&)">mouseWheelEvent</a>(const BMouseEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#mouseClickEvent(const BMouseEvent&)">mouseClickEvent</a>(const BMouseEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#mouseDoubleClickEvent(const BMouseEvent&)">mouseDoubleClickEvent</a>(const BMouseEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#dragEnterEvent(const BDragEvent&)">dragEnterEvent</a>(const BDragEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#dragLeaveEvent(const BDragEvent&)">dragLeaveEvent</a>(const BDragEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#dragMoveEvent(const BDragEvent&)">dragMoveEvent</a>(const BDragEvent& event);</td></tr>
			<tr><td align="right">virtual void </td><td><a href="#dragDropEvent(const BDragEvent&)">dragDropEvent</a>(const BDragEvent& event);</td></tr>
		</table>
		<div id="desc">
			<h2>Detailed Description : </h2>
			<p>The BWidget class is the base class of all user interface objects.</p>
			<p>A widget has no parent is a root widget, when it's hown it is a window. BMainWindow and BDialog will be good to root window.</p>
			<p>The widget is the atom of the user interface: it receives mouse, keyboard and other events from the window system, and paints a representation of itself on the screen. A widget is clipped by its parent and by the widgets in front of it.</p>
		</div>
		<h2 id="docs">Member Documentation</h2>
		<div id="BWidget(BWidget*)">
			<h3>BWidget(BWidget* parent = 0);</h3>
			<p>Constructs a widget with parent. If a widget is shown without parent it is a root window. It is recommended to constructs your self define widget with parent, it is good hobby.</p>
		</div>
		<div id="BWidget(const BString&,BWidget*)">
			<h3>BWidget(const BString& name, BWidget* parent = 0);</h3>
			<p>Constructs a widget with name and parent, somtimes this is convenient.</p>
		</div>
		<div id="~BWidget()">
			<h3>~BWidget();</h3>
			<p>Destroys this widget.All this widget's children are deleted first. The application exits if this widget is the main widget.</p>
		</div>
		<div id="active()">
			<h3>bool active() const;</h3>
			<p>Checks if this widget is active.A widget is active means it has cursor focus or one of it's children does.</p>
		</div>
		<div id="show()">
			<h3>void show();</h3>
			<p>If widget's parent is none widget will show as a root window.</p>
		</div>
		<div id="hide()">
			<h3>void hide();</h3>
			<p>Hide widget, equals setVisible(false).</p>
		</div>
		<div id="popup()">
			<h3>void popup();</h3>
			<p>Popup the widget, The widget popuped won't hiden by parents except root window.</p>
		</div>
		<div id="raise()">
			<h3>void raise();</h3>
			<p>Raise widget to first index in parent's children list.</p>
		</div>
		<div id="lower()">
			<h3>void lower();</h3>
			<p>Move widget to last index in parent's children list.</p>
		</div>
		<div id="fresh()">
			<h3>void fresh();</h3>
			<p>Repaint this widget.</p>
		</div>
		<div id="adjust()">
			<h3>void adjust();</h3>
			<p>Dirty this widget's layouts and parent's layout which contain this widget to root widget. </p>
		</div>
		<div id="setAble(bool)">
			<h3>virtual bool setAble(bool able);</h3>
			<p>Reimplemented from BWidget::setAble(bool) to refresh widget.</p>
		</div>
		<div id="setTitle(const BString&)">
			<h3>virtual bool setTitle(const BString& title);</h3>
			<p>Change the title of this widget, if successed Signal_TitleChanged will be emited. Just a few widget show the title, eg BMainWindow, BDialog, BTabWidget's tab and BMenuBar.</p>
		</div>
		<div id="title()">
			<h3>const BString& title() const;</h3>
			<p>Get title of widget.</p>
		</div>
		<div id="setTitleIcon(BIcon*)">
			<h3>virtual bool setTitleIcon(BIcon* titleIcon);</h3>
			<p>Set title icon of widget, if title icon is changed widget emits Signal_TitleIconChanged.</p>
		</div>
		<div id="titleIcon()">
			<h3>const BIcon* titleIcon() const;</h3>
			<p>Get the title icon of widget.</p>
		</div>
		<div id="titleIcon()">
			<h3>BIcon* titleIcon();</h3>
		</div>
		<div id="setTips(const BString&)">
			<h3>void setTips(const BString& tips);</h3>
			<p>Changes tool tips of this widget, tool tips will show up if cursor enter this widget and stop for a while.</p>
		</div>
		<div id="tips()">
			<h3>const BString& tips() const;</h3>
			<p>Return tips text.</p>
		</div>
		<div id="setVisible(bool)">
			<h3>void setVisible(bool visible);</h3>
			<p>Change visible of widget. if widget has no parent it will be shown, you can show it up as root window using show().</p>
		</div>
		<div id="visible()">
			<h3>bool visible() const;</h3>
			<p>Checks if this widget is visible.</p>
		</div>
		<div id="setModal(bool)">
			<h3>void setModal(bool modal);</h3>
			<p>Set widget modal, a modal widget blocks mouse event while it's popup.</p>
		</div>
		<div id="modal()">
			<h3>bool modal() const;</h3>
			<p>Get widget modal.</p>
		</div>
		<div id="setFloating(bool)">
			<h3>void setFloating(bool floating);</h3>
			<p>If widget floating is false, widget will culled by client rect of parent widget.</p>
		</div>
		<div id="floating()">
			<h3>bool floating() const;</h3>
			<p>Get floating value of widget.</p>
		</div>
		<div id="setDroppable(bool)">
			<h3>void setDroppable(bool droppable);</h3>
			<p>If widget is droppable it accepts drag dropping.</p>
		</div>
		<div id="droppable()">
			<h3>bool droppable() const;</h3>
		</div>
		<div id="setFocusable(bool)">
			<h3>void setFocusable(bool focusable);</h3>
			<p>If this widget is no focusable the method setFocus(bool) won't work.</p>
		</div>
		<div id="focusable()">
			<h3>bool focusable() const;</h3>
			<p>Checks if this widget is focusable.</p>
		</div>
		<div id="setFocus(bool)">
			<h3>void setFocus(bool focus);</h3>
			<p>Change widget's focus state, if successed Signal_Focused will be emited. If this widget is not focusable this method won't work.</p>
		</div>
		<div id="focus()">
			<h3>bool focus() const;</h3>
			<p>Checks if this widget is focused.</p>
		</div>
		<div id="move(const BPoint&)">
			<h3>void move(const BPoint& offset);</h3>
		</div>
		<div id="move(int, int)">
			<h3>void move(int ox, int oy);</h3>
			<p>Equals setPos(this-&gtpos() + BPoint(ox, oy));</p>
		</div>
		<div id="setPos(int, int)">
			<h3>void setPos(int x, int y);</h3>
			<p>Equals setPos(BPoint(x, y)).</p>
		</div>
		<div id="setPos(const BPoint&)">
			<h3>virtual void setPos(const BPoint& pos);</h3>
		</div>
		<div id="pos()">
			<h3>const BPoint& pos() const;</h3>
			<p>Get left top point of widget rectangle relating to the parent widget.</p>
		</div>
		<div id="setSize(int, int)">
			<h3>void setSize(int width, int height);</h3>
			<p>Equals setSize(BSize(width, height)).</p>
		</div>
		<div id="setSize(const BSize&)">
			<h3>void setSize(const BSize& size);</h3>
		</div>
		<div id="size()">
			<h3>const BSize& size() const;</h3>
			<p>Return size of this widget.</p>
		</div>
		<div id="setWidth(int)">
			<h3>void setWidth(int width);</h3>
			<p>Equals setSize(BSize(width, this-&gtheight())).</p>
		</div>
		<div id="width()">
			<h3>int width() const;</h3>
			<p>Get width of this widget.</p>
		</div>
		<div id="setHeight(int)">
			<h3>void setHeight(int height);</h3>
			<p>Equals setSize(BSize(this-&gtwidth(), height)).</p>
		</div>
		<div id="height()">
			<h3>int height() const;</h3>
			<p>Return height of this widget.</p>
		</div>
		<div id="setAbsolutePos(const BPoint&)">
			<h3>void setAbsolutePos(const BPoint& pos);</h3>
		</div>
		<div id="setAbsolutePos(int, int)">
			<h3>void setAbsolutePos(int absoluteX, int absoluteY);</h3>
			<p>Equals setAbsolutePos(BPoint(absoluteX, absoluteY)).</p>
		</div>
		<div id="absolutePos()">
			<h3>BPoint absolutePos() const;</h3>
			<p>Return widget's pos relative to root widget.</p>
		</div>
		<div id="setGlobalPos(const BPoint&)">
			<h3>void setGlobalPos(const BPoint& globalPos);</h3>
		</div>
		<div id="setGlobalPos(int, int)">
			<h3>void setGlobalPos(int globalX, int globalY);</h3>
		</div>
		<div id="globalPos()">
			<h3>BPoint globalPos() const;</h3>
		</div>
		<div id="setRect(const BRect&)">
			<h3>void setRect(const BRect& rect);</h3>
		</div>
		<div id="setRect(int, int, int, int)">
			<h3>void setRect(int x, int y, int width, int height);</h3>
			<p>Equals setPos(x, y) and setSize(width, height).</p>
		</div>
		<div id="rect()">
			<h3>BRect rect() const;</h3>
			<p>Get widget's rect relative to it's parent.</p>
		</div>
		<div id="rect(Part)">
			<h3>BRect rect(Part part) const;</h3>
			<p>Get widget's rect specified by part. You can get seven rects relative to part.</p><table>
				<tr><td>Part_Title</td><td>Return title rect, it's left and right close to border.</td></tr>
				<tr><td>Part_Top</td><td>Return top perch rect.</td></tr>
				<tr><td>Part_Left</td><td>Return left perch rect.</td></tr>
				<tr><td>Part_Right</td><td>Return right perch rect.</td></tr>
				<tr><td>Part_Bottom</td><td>Return bottom perch rect.</td></tr>
				<tr><td>Part_Central</td><td>Return central rect equals clientRect().</td></tr>
				<tr><td>Part_None</td><td>Return total rect equals rect().</td></tr></table>
		</div>
		<div id="setAbsoluteRect(const BRect&)">
			<h3>void setAbsoluteRect(const BRect& rect);</h3>
		</div>
		<div id="setAbsoluteRect(int, int, int, int)">
			<h3>void setAbsoluteRect(int x, int y, int width, int height);</h3>
		</div>
		<div id="absoluteRect()">
			<h3>BRect absoluteRect() const;</h3>
		</div>
		<div id="setGlobalRect(const BRect&)">
			<h3>void setGlobalRect(const BRect& rect);</h3>
		</div>
		<div id="setGlobalRect(int, int, int, int)">
			<h3>void setGlobalRect(int x, int y, int width, int height);</h3>
		</div>
		<div id="globalRect()">
			<h3>BRect globalRect() const;</h3>
			<p>Global rect is rect to screen origin point.</p>
		</div>
		<div id="mapTo(const BWidget*, const BPoint&)">
			<h3>BPoint mapTo(const BWidget* widget, const BPoint& point) const;</h3>
		</div>
		<div id="mapFrom(const BWidget*, const BPoint&)">
			<h3>BPoint mapFrom(const BWidget* widget, const BPoint& point) const;</h3>
		</div>
		<div id="mapTo(const BWidget*, const BRect&)">
			<h3>BRect mapTo(const BWidget* widget, const BRect& rect) const;</h3>
		</div>
		<div id="mapFrom(const BWidget*, const BRect&)">
			<h3>BRect mapFrom(const BWidget* widget, const BRect& rect) const;</h3>
		</div>
		<div id="setMinSize(const BSize&)">
			<h3>void setMinSize(const BSize& minSize);</h3>
		</div>
		<div id="setMinSize(int, int)">
			<h3>void setMinSize(int minWidth, int minHeight);</h3>
			<p>Equals setMinSize(BSize(minWidth, minHeight));</p>
		</div>
		<div id="minSize()">
			<h3>const BSize& minSize() const;</h3>
			<p>Return min size of this widget.</p>
		</div>
		<div id="setMaxSize(const BSize&)">
			<h3>void setMaxSize(const BSize& maxSize);</h3>
		</div>
		<div id="setMaxSize(int, int)">
			<h3>void setMaxSize(int maxWidth, int maxHeight);</h3>
			<p>Equals setMaxSize(BSize(maxWidth, maxHeight)).</p>
		</div>
		<div id="maxSize()">
			<h3>const BSize& maxSize() const;</h3>
			<p>Return max size of this widget.</p>
		</div>
		<div id="setFixedWidth(int)">
			<h3>void setFixedWidth(int fixedWidth);</h3>
			<p>Set widget fixed width, and change widget's width polcy to Policy_Fixed.</p>
		</div>
		<div id="setFixedHeight(int)">
			<h3>void setFixedHeight(int fixedHeight);</h3>
			<p>Set widget fixed height, and change widget's height policy to Policy_Fixed.</p>
		</div>
		<div id="setFixedSize(int, int)">
			<h3>void setFixedSize(int fixedWidth, int fixedHeight);</h3>
			<p>Equals setFixedSize(BSize(fixedWidth, fixedHeight)).</p>
		</div>
		<div id="setFixedSize(const BSize&)">
			<h3>void setFixedSize(const BSize& fixedSize);</h3>
		</div>
		<div id="fixedSize()">
			<h3>const BSize& fixedSize() const;</h3>
		</div>
		<div id="setWidthStretch(float)">
			<h3>void setWidthStretch(float widthStretch);</h3>
			<p>Set width stretch, layout adjust widgets depends stretch of each widget.</p>
		</div>
		<div id="widthStretch()">
			<h3>float widthStretch() const;</h3>
		</div>
		<div id="setHeightStretch(float)">
			<h3>void setHeightStretch(float heightStretch);</h3>
		</div>
		<div id="heightStretch()">
			<h3>float heightStretch() const;</h3>
		</div>
		<div id="setSizeStretch(float, float)">
			<h3>void setSizeStretch(float widthStretch, float heightStretch);</h3>
			<p>Layout will distribute redundant size to each of items relative to their size stretchs.</p>
		</div>
		<div id="setSizeStretch(const BSizeStretch&)">
			<h3>void setSizeStretch(const BSizeStretch& sizeStretch);</h3>
		</div>
		<div id="sizeStretch()">
			<h3>const BSizeStretch& sizeStretch() const;</h3>
		</div>
		<div id="setWidthPolicy(Policy)">
			<h3>void setWidthPolicy(Policy widthPolicy);</h3>
			<p>Equals setSizePolicy(BSizePolicy(widthPolicy, this-&gtheightPolicy())).</p>
		</div>
		<div id="widthPolicy()">
			<h3>Policy widthPolicy() const;</h3>
		</div>
		<div id="setHeightPolicy(Policy)">
			<h3>void setHeightPolicy(Policy heightPolicy);</h3>
			<p>Equals setSizePolicy(BSizePolicy(this-&gtwidthPolicy(), heightPolicy)).</p>
		</div>
		<div id="heightPolicy()">
			<h3>Policy heightPolicy() const;</h3>
		</div>
		<div id="setSizePolicy(Policy, Policy)">
			<h3>void setSizePolicy(Policy widthPolicy, Policy heightPolicy);</h3>
			<p>Equals setSizePolicy(BSizePoicy(widthPolicy, heightPolicy)).</p>
		</div>
		<div id="setSizePolicy(const BSizePolicy&)">
			<h3>void setSizePolicy(const BSizePolicy& sizePolicy);</h3>
		</div>
		<div id="sizePolicy()">
			<h3>const BSizePolicy& sizePolicy() const;</h3>
		</div>
		<div id="setClientSize(const BSize&)">
			<h3>void setClientSize(const BSize& clientSize);</h3>
		</div>
		<div id="setClientSize(int, int)">
			<h3>void setClientSize(int clientWidth, int clientHeight);</h3>
		</div>
		<div id="clientRect()">
			<h3>const BRect& clientRect() const;</h3>
			<p>Client rect is rect unclude border, perch and margin.</p>
		</div>
		<div id="clientSize()">
			<h3>BSize clientSize() const;</h3>
		</div>
		<div id="setBorder(int)">
			<h3>void setBorder(int border);</h3>
			<p>Border is outermost layer of widget, if successed resizeEvent will called and Signal_Resize will be emited. It is value of Value_Border in style.</p>
		</div>
		<div id="border()">
			<h3>int border() const;</h3>
			<p>Return border of widget.</p>
		</div>
		<div id="setPerchs(const BPerchs&)">
			<h3>void setPerchs(const BPerchs& perchs);</h3>
		</div>
		<div id="setPerchs(int, int, int, int)">
			<h3>void setPerchs(int left, int top, int right, int bottom);</h3>
			<p>Equals setPerchs(BPerchs(left, top, right, bottom)).</p>
		</div>
		<div id="perchs()">
			<h3>const BPerchs& perchs() const;</h3>
			<p>Get perchs of widget.</p>
		</div>
		<div id="setPerch(Part, int)">
			<h3>void setPerch(Part part, int value);</h3>
			<p>Set value of specail part of perch, If part is mixed of several Part their value will be set together.</p>
		</div>
		<div id="perch(Part)">
			<h3>int perch(Part part) const;</h3>
			<p>Get value of special part of perch.</p>
		</div>
		<div id="setMargins(const BMargins&)">
			<h3>void setMargins(const BMargins& margins);</h3>
		</div>
		<div id="setMargins(int, int, int, int)">
			<h3>void setMargins(int left, int top, int right, int bottom);</h3>
			<p>Equals setMargins(BMargins(left, top, right, bottom)).</p>
		</div>
		<div id="margins()">
			<h3>const BMargins& margins() const;</h3>
			<p>Return margins of widget.</p>
		</div>
		<div id="setMargin(Part, int)">
			<h3>void setMargin(Part part, int value);</h3>
			<p>Set value of special part of margins. Several part of margins can be set together by a mixed part value, eg Part_All.</p>
		</div>
		<div id="margin(Part)">
			<h3>int margin(Part part) const;</h3>
			<p>Get value of special part of margins.</p>
		</div>
		<div id="setCursor(CursorType)">
			<h3>void setCursor(CursorType cursor);</h3>
			<p>This is covenient way to set cursor of this widget. Signal_CursorChanged will be emited if successed.</p>
		</div>
		<div id="setCursor(BCursor*)">
			<h3>void setCursor(BCursor* cursor);</h3>
			<p>Change the cursor of this widget, if successed Signal_CursorChanged will be emited.</p>
		</div>
		<div id="cursor()">
			<h3>BCursor* cursor();</h3>
			<p>Get widget's cursor.</p>
		</div>
		<div id="cursor()">
			<h3>const BCursor* cursor() const;</h3>
		</div>
		<div id="realCursor()">
			<h3>const BCursor* realCursor() const;</h3>
			<p>Return own cursor if widget has cursor, otherwise return cusor of parent which has cursor.</p>
		</div>
		<div id="setFont(BFont*)">
			<h3>void setFont(BFont* font);</h3>
			<p>If widget has a self font, the font will be stored in a self style.</p>
		</div>
		<div id="setFont(const BString&,int)">
			<h3>void setFont(const BString& family, int size = 20);</h3>
		</div>
		<div id="font()">
			<h3>const BFont* font() const;</h3>
			<p>Get the font used of this widget, but it is not hold by this widget.</p>
		</div>
		<div id="setStyle(BStyle*)">
			<h3>void setStyle(BStyle* style);</h3>
			<p>Set local style, if this widget has no own style you can get real style which is hold by parent or global style. It is good idea to set the style using style sheet by BApplication::setStyleSheet(fileName). A style of widget will be used by this widget and all of children. </p>
			<p>See also : <a href="BStyle.html">BStyle</a><a href="#setStyleSheet(const BString&)">setStyleSheet()</a></p>
		</div>
		<div id="style()">
			<h3>BStyle* style() const;</h3>
			<p>Get owned style.</p>
		</div>
		<div id="realStyle()">
			<h3>BStyle* realStyle() const;</h3>
			<p>Get real style used by this widget, it could be hold by parent.</p>
		</div>
		<div id="setStyleSheet(const BString&)">
			<h3>void setStyleSheet(const BString& styleSheet);</h3>
			<p>If styleSheet is a file name the file will be load to create a style for this widget, otherwise styleSheet will be read as a text to create a style. Then the styleSheet will stored in this widget.</p>
		</div>
		<div id="styleSheet()">
			<h3>const BString& styleSheet() const;</h3>
			<p>Get the style sheet stored in this widget, it is useful when you want edit the sheet.</p>
		</div>
		<div id="setLayout(BLayout*,Part)">
			<h3>void setLayout(BLayout* layout, Part part = Part_Center);</h3>
			<p>Set layout of special part of widget. Widget's size is effected by the layouts in it. A widget can hold six layouts.This widget will take ownership of layout.</p>
		</div>
		<div id="layout(Part)">
			<h3>BLayout* layout(Part part = Part_Center);</h3>
			<p>Get layout of the specail part of widget.</p>
		</div>
		<div id="layout(Part)">
			<h3>const BLayout* layout(Part part = Part_Center) const;</h3>
		</div>
		<div id="removeLayout(BLayout*)">
			<h3>bool removeLayout(BLayout* layout);</h3>
			<p>Remove the layout from this widget, and the children in it will be free stay where they are.</p>
		</div>
		<div id="preferSize(const BSize&)">
			<h3>BSize preferSize(const BSize& csize) const;</h3>
		</div>
		<div id="sizeHint()">
			<h3>virtual BSize sizeHint() const;</h3>
			<p>Get the prefer size with csize equlas BSize(0, 0), this function is often reimplemented by sub class.</p>
		</div>
		<div id="hintSize()">
			<h3>void hintSize();</h3>
			<p>Equals setSize(this-&gtsizeHint()). Is this useful ?</p>
		</div>
		<div id="catchPoint(const BPoint&)">
			<h3>virtual bool catchPoint(const BPoint& point) const;</h3>
		</div>
		<div id="root()">
			<h3>BWidget* root();</h3>
			<p>Return the root widget of this widget. if result equals this means this is a root window.</p>
		</div>
		<div id="root()">
			<h3>const BWidget* root() const;</h3>
		</div>
		<div id="setParent(BWidget*)">
			<h3>void setParent(BWidget* parent);</h3>
			<p>Equals parent-&gtaddChild(this).</p>
		</div>
		<div id="parent()">
			<h3>BWidget* parent();</h3>
			<p>Get the parent widget of this.</p>
		</div>
		<div id="parent()">
			<h3>const BWidget* parent() const;</h3>
		</div>
		<div id="addChild(BWidget*)">
			<h3>void addChild(BWidget* child);</h3>
			<p>Add the a child widget, if successed this widget will take ownship of the child, and refresh the style tree for the child.</p>
		</div>
		<div id="removeChild(BWidget*)">
			<h3>void removeChild(BWidget* child);</h3>
			<p>Remove the child widget from children list, if the child widget was in a layout this widget will call adjust() to refresh the rects.</p>
		</div>
		<div id="clearChildren()">
			<h3>void clearChildren();</h3>
			<p>Remove all children.</p>
		</div>
		<div id="childCount()">
			<h3>int childCount() const;</h3>
			<p>Get number of children, you want visit every child probably.</p>
		</div>
		<div id="child(int)">
			<h3>BWidget* child(int index);</h3>
			<p>Return the child indexed in the children list.</p>
		</div>
		<div id="child(int)">
			<h3>const BWidget* child(int index) const;</h3>
		</div>
		<div id="child(const BString&)">
			<h3>BWidget* child(const BString& name);</h3>
			<p>Find a named widget in children list. if there is not only one child matchs the name return first.</p>
		</div>
		<div id="child(const BString&)">
			<h3>const BWidget* child(const BString& name) const;</h3>
			<p>Find first named widget in children list.</p>
		</div>
		<div id="find(const BString&)">
			<h3>BWidget* find(const BString& name);</h3>
			<p>Find a named widget under this widget, the named widget does't have to be child but child of child.</p>
		</div>
		<div id="find(const BString&)">
			<h3>const BWidget* find(const BString& name) const;</h3>
			<p>Find a named widget under this widget, the named widget does't have to be child but child of child.</p>
		</div>
		<div id="contains(const BWidget*)">
			<h3>bool contains(const BWidget* child);</h3>
			<p>Checks if this widget contains child in the children list.</p>
		</div>
		<div id="index()">
			<h3>int index() const;</h3>
			<p>Return index of this widget in parent's children list. You can move the index to head of list using raise(), or move the index to tail of list using lower().</p>
		</div>
		<div id="event(const BEvent&)">
			<h3 id="event(const BEvent&)">virtual void event(const BEvent& event);</h3>
			<p>Enter of processing any event. </p>
		</div>
		<div id="showEvent(const BEvent&)">
			<h3 id="showEvent(const BEvent&)">virtual void showEvent(const BEvent& event);</h3>
			<p>Each time this widget is shown up this method will be called. Signal_Show is emited here.</p>
		</div>
		<div id="hideEvent(const BEvent&)">
			<h3 id="hideEvent(const BEvent&)">virtual void hideEvent(const BEvent& event);</h3>
			<p>Each itme this widget is hiden this method will be called. Signal_Hide is emited here.</p>
		</div>
		<div id="moveEvent(const BEvent&)">
			<h3 id="moveEvent(const BEvent&)">virtual void moveEvent(const BEvent& event);</h3>
			<p>This will be called when widget's position is changed. Signal_Move is emited here.</p>
		</div>
		<div id="resizeEvent(const BEvent&)">
			<h3 id="resizeEvent(const BEvent&)">virtual void resizeEvent(const BEvent& event);</h3>
			<p>This will be called when widget's size is changed. Signal_Resize is emited here.</p>
		</div>
		<div id="updateEvent(const BEvent&)">
			<h3 id="updateEvent(const BEvent&)">virtual void updateEvent(const BEvent& event);</h3>
			<p>This will be called once every frame, duration between two frame is up to frequency of application.</p>
		</div>
		<div id="adjustEvent(const BEvent&)">
			<h3 id="adjustEvent(const BEvent&)">virtual void adjustEvent(const BEvent& event);</h3>
			<p>This will be called when layout's is adjusted. Signal_Adjust is emited here.</p>
		</div>
		<div id="styleEvent(const BEvent&)">
			<h3 id="styleEvent(const BEvent&)">virtual void styleEvent(const BEvent& event);</h3>
			<p>This will be called when this widget's style environment changed, you could get current style using BWidget::realStyle(), then get infos from it.</p>
		</div>
		<div id="freshEvent(const BEvent&)">
			<h3 id="freshEvent(const BEvent&)">virtual void freshEvent(const BEvent& event);</h3>
			<p>This will be called each time paintEvent will be called. Calling BWidget::fresh() won't case this event if widget is not visible.</p>
		</div>
		<div id="paintEvent(const BEvent&)">
			<h3 id="paintEvent(const BEvent&)">virtual void paintEvent(const BEvent& event);</h3>
			<p>This will be called when this widget need to repaint. You can reimplement this method to paint widget as you want.</p>
			<p>When you start to paint you need construct a BPainter or you use OpenGL function to paint.</p>
		</div>
		<div id="activeEvent(const BActiveEvent&)">
			<h3 id="activeEvent(const BActiveEvent&)">virtual void activeEvent(const BActiveEvent& event);</h3>
			<p>When widget's active state changed this will called. Active widget is the widget which has focus or any child has focus.</p>
		</div>
		<div id="focusEvent(const BFocusEvent&)">
			<h3 id="focusEvent(const BFocusEvent&)">virtual void focusEvent(const BFocusEvent& event);</h3>
			<p>When this widget start to have focus or lost focus this will be called. Signal_Focus is emited here.</p>
		</div>
		<div id="keyDownEvent(const BKeyEvent&)">
			<h3 id="keyDownEvent(const BKeyEvent&)">virtual void keyDownEvent(const BKeyEvent& event);</h3>
			<p>This will be called when any key is push down. If you want catch this event you must make sure this widget is enabled.</p>
		</div>
		<div id="keyUpEvent(const BKeyEvent&)">
			<h3 id="keyUpEvent(const BKeyEvent&)">virtual void keyUpEvent(const BKeyEvent& event);</h3>
			<p>This will be called when any key is released if this widget is enabled.</p>
		</div>
		<div id="charEvent(const BCharEvent&)">
			<h3 id="charEvent(const BCharEvent&)">virtual void charEvent(const BCharEvent& event);</h3>
			<p>This will be called when a character is input, not any key push down.</p>
		</div>
		<div id="mouseEnterEvent(const BMouseEvent&)">
			<h3 id="mouseEnterEvent(const BMouseEvent&)">virtual void mouseEnterEvent(const BMouseEvent& event);</h3>
			<p>This will be called when cursor move enter this widget.</p>
		</div>
		<div id="mouseLeaveEvent(const BMouseEvent&)">
			<h3 id="mouseLeaveEvent(const BMouseEvent&)">virtual void mouseLeaveEvent(const BMouseEvent& event);</h3>
			<p>This will be called when cursor leave this widget.</p>
		</div>
		<div id="mousePressEvent(const BMouseEvent&)">
			<h3 id="mousePressEvent(const BMouseEvent&)">virtual void mousePressEvent(const BMouseEvent& event);</h3>
			<p>This will be called when mouse button pressed.</p>
		</div>
		<div id="mouseReleaseEvent(const BMouseEvent&)">
			<h3 id="mouseReleaseEvent(const BMouseEvent&)">virtual void mouseReleaseEvent(const BMouseEvent& event);</h3>
			<p>This will be called when mouse button released.</p>
		</div>
		<div id="mouseMoveEvent(const BMouseEvent&)">
			<h3 id="mouseMoveEvent(const BMouseEvent&)">virtual void mouseMoveEvent(const BMouseEvent& event);</h3>
			<p>This will be called when cursor moving in this widget.</p>
		</div>
		<div id="mouseWheelEvent(const BMouseEvent&)">
			<h3 id="mouseWheelEvent(const BMouseEvent&)">virtual void mouseWheelEvent(const BMouseEvent& event);</h3>
			<p>This will be called when mouse middle wheel rotates.</p>
		</div>
		<div id="mouseClickEvent(const BMouseEvent&)">
			<h3 id="mouseClickEvent(const BMouseEvent&)">virtual void mouseClickEvent(const BMouseEvent& event);</h3>
			<p>When a mouse button is released and duration from the moment it pressed is less than a specail time, and in this duration cursor position does't change too much this event occurs.</p>
			<p>The duration between button pressed and released is up to application's setting. Signal_Clicked is emited here.</p>
		</div>
		<div id="mouseDoubleClickEvent(const BMouseEvent&)">
			<h3 id="mouseDoubleClickEvent(const BMouseEvent&)">virtual void mouseDoubleClickEvent(const BMouseEvent& event);</h3>
			<p>If two clicked event occurs in a shot moment and their position is closed this event occurs. Signal_DoubleClicked is emited here.</p>
		</div>
		<div id="dragEnterEvent(const BDragEvent&)">
			<h3 id="dragEnterEvent(const BDragEvent&)">virtual void dragEnterEvent(const BDragEvent& event);</h3>
			<p>When cursor enters this widget with dragging an object this will called.</p>
		</div>
		<div id="dragLeaveEvent(const BDragEvent&)">
			<h3 id="dragLeaveEvent(const BDragEvent&)">virtual void dragLeaveEvent(const BDragEvent& event);</h3>
			<p>When cursor leaves this widget with dragging an object this will be called.</p>
		</div>
		<div id="dragMoveEvent(const BDragEvent&)">
			<h3 id="dragMoveEvent(const BDragEvent&)">virtual void dragMoveEvent(const BDragEvent& event);</h3>
			<p>When cursor moved in this widget with dragging an object this will be called.</p>
		</div>
		<div id="dragDropEvent(const BDragEvent&)">
			<h3 id="dragDropEvent(const BDragEvent&)">virtual void dragDropEvent(const BDragEvent& event);</h3>
			<p>When mouse button released in this widget with dragging an object this will be called.</p>
			<p/>
		</div>
	</body>
</html>